package org.dromara.system.api.services;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.dromara.common.core.domain.R;
import org.dromara.common.core.utils.AssertUtils;
import org.dromara.system.api.domain.bo.RemoteUserBo;
import org.dromara.system.api.domain.vo.RemoteUserVo;
import org.dromara.system.api.feign.SystemUserClient;
import org.dromara.common.core.domain.model.LoginUser;
import org.dromara.common.core.domain.model.XcxLoginUser;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Map;

/**
 * @author: zhou shuai
 * @date: 2024/10/6 16:13
 * @version: v1
 */
@Slf4j
@Service("systemUserApiService")
@RequiredArgsConstructor
public class SystemUserApiService {

    private final SystemUserClient systemUserClient;

    /**
     * 通过用户名查询用户信息
     *
     * @param userName 用户名
     * @param tenantId 租户id
     * @return 结果
     */
    public LoginUser getUserInfoByUserName(String userName, String tenantId) {
        R<LoginUser> userByNameResult = systemUserClient.getUserInfoByUserName(userName, tenantId);
        AssertUtils.assertTrue(R.isSuccess(userByNameResult), "通过用户名查询用户信息失败");
        return userByNameResult.getData();
    }

    /**
     * 通过用户id查询用户信息
     *
     * @param userId   用户id
     * @param tenantId 租户id
     * @return 结果
     */
    public LoginUser getUserInfoByUserId(Long userId, String tenantId) {
        R<LoginUser> userByUserIdResult = systemUserClient.getUserInfoByUserId(userId, tenantId);
        AssertUtils.assertTrue(R.isSuccess(userByUserIdResult), "通过用户id查询用户信息失败");
        return userByUserIdResult.getData();
    }

    /**
     * 通过手机号查询用户信息
     *
     * @param phoneNumber 手机号
     * @param tenantId    租户id
     * @return 结果
     */
    public LoginUser getUserInfoByPhoneNumber(String phoneNumber, String tenantId) {
        R<LoginUser> userByPhoneNumberResult = systemUserClient.getUserInfoByPhoneNumber(phoneNumber, tenantId);
        AssertUtils.assertTrue(R.isSuccess(userByPhoneNumberResult), "通过手机号查询用户信息失败");
        return userByPhoneNumberResult.getData();
    }

    /**
     * 通过邮箱查询用户信息
     *
     * @param email    邮箱
     * @param tenantId 租户id
     * @return 结果
     */
    public LoginUser getUserInfoByEmail(String email, String tenantId) {
        R<LoginUser> userByEmailResult = systemUserClient.getUserInfoByEmail(email, tenantId);
        AssertUtils.assertTrue(R.isSuccess(userByEmailResult), "通过邮箱查询用户信息失败");
        return userByEmailResult.getData();
    }

    /**
     * 通过openId查询用户信息
     *
     * @param openId
     * @return 结果
     */
    public XcxLoginUser getUserInfoByOpenId(String openId) {
        R<XcxLoginUser> userByOpenIdResult = systemUserClient.getUserInfoByOpenId(openId);
        AssertUtils.assertTrue(R.isSuccess(userByOpenIdResult), "通过openId查询用户信息失败");
        return userByOpenIdResult.getData();
    }

    /**
     * 注册用户信息
     *
     * @param remoteUserBo 用户信息
     * @return 结果
     */
    public Boolean userRegister(RemoteUserBo remoteUserBo) {
        R<Boolean> userRegisterResult = systemUserClient.userRegister(remoteUserBo);
        AssertUtils.assertTrue(R.isSuccess(userRegisterResult), "用户注册失败");
        return userRegisterResult.getData();
    }

    /**
     * 重置用户密码
     *
     * @param userId   用户id
     * @param password 用户密码
     * @return 结果
     */
    public Boolean resetUserPas(Long userId, String password) {
        R<Boolean> resetPasResult = systemUserClient.resetUserPas(userId, password);
        AssertUtils.assertTrue(R.isSuccess(resetPasResult), "重置用户密码失败");
        return resetPasResult.getData();
    }

    /**
     * 通过用户ID查询用户名
     *
     * @param userId 用户ID
     * @return 用户名
     */
    public String selectUserNameById(Long userId) {
        R<String> userNameResult = systemUserClient.selectUserNameById(userId);
        AssertUtils.assertTrue(R.isSuccess(userNameResult), "通过用户ID查询用户名失败");
        return userNameResult.getData();
    }

    /**
     * 通过用户ID查询岗位名称
     *
     * @param userId 用户ID
     * @return 岗位名称
     */
    public String selectPostNameById(Long userId) {
        R<String> postNameResult = systemUserClient.selectPostnameById(userId);
        AssertUtils.assertTrue(R.isSuccess(postNameResult), "通过用户ID查询岗位名称失败");
        return postNameResult.getData();
    }

    /**
     * 通过用户ID查询角色名称
     *
     * @param userId 用户ID
     * @return 角色名称
     */
    public String selectRoleNameById(Long userId) {
        R<String> roleNameResult = systemUserClient.selectRolenameById(userId);
        AssertUtils.assertTrue(R.isSuccess(roleNameResult), "通过用户ID查询角色名称失败");
        return roleNameResult.getData();
    }

    /**
     * 通过用户ID集合查询用户昵称集合
     *
     * @param userIds 用户ID 多个用逗号隔开
     * @return 用户昵称集合
     */
    public String selectNickNameByIds(String userIds) {
        R<String> nickNameResult = systemUserClient.selectNickNameByIds(userIds);
        AssertUtils.assertTrue(R.isSuccess(nickNameResult), "通过用户ID查询用户昵称失败");
        return nickNameResult.getData();
    }

    /**
     * 更新用户信息
     *
     * @param userId 用户ID
     * @param ip     IP地址
     */
    public void recordLoginInfo(Long userId, String ip) {
        systemUserClient.recordLoginInfo(userId, ip);
    }

    /**
     * 通过用户ID查询用户列表
     *
     * @param userIds 用户ids
     * @return 用户列表
     */
    public List<RemoteUserVo> selectListByIds(List<Long> userIds) {
        R<List<RemoteUserVo>> userListResult = systemUserClient.selectListByIds(userIds);
        AssertUtils.assertTrue(R.isSuccess(userListResult), "通过用户ID查询用户列表失败");
        return userListResult.getData();
    }

    /**
     * 通过角色ID查询用户ID
     *
     * @param roleIds 角色ids
     * @return 用户ids
     */
    public List<Long> selectUserIdsByRoleIds(List<Long> roleIds) {
        R<List<Long>> userIdListResult = systemUserClient.selectUserIdsByRoleIds(roleIds);
        AssertUtils.assertTrue(!R.isError(userIdListResult), "通过角色ID查询用户ID失败");
        return userIdListResult.getData();
    }

    /**
     * 通过角色ID查询用户
     *
     * @param roleIds 角色ids
     * @return 用户
     */
    public List<RemoteUserVo> selectUsersByRoleIds(List<Long> roleIds) {
        R<List<RemoteUserVo>> userListResult = systemUserClient.selectUsersByRoleIds(roleIds);
        AssertUtils.assertTrue(R.isSuccess(userListResult), "通过角色ID查询用户列表失败");
        return userListResult.getData();
    }

    /**
     * 通过部门ID查询用户
     *
     * @param deptIds 部门ids
     * @return 用户
     */
    public List<RemoteUserVo> selectUsersByDeptIds(List<Long> deptIds) {
        R<List<RemoteUserVo>> userListResult = systemUserClient.selectUsersByDeptIds(deptIds);
        AssertUtils.assertTrue(R.isSuccess(userListResult), "通过部门ID查询用户列表失败");
        return userListResult.getData();
    }

    /**
     * 通过岗位ID查询用户
     *
     * @param postIds 岗位ids
     * @return 用户
     */
    public List<RemoteUserVo> selectUsersByPostIds(List<Long> postIds) {
        R<List<RemoteUserVo>> userListResult = systemUserClient.selectUsersByPostIds(postIds);
        AssertUtils.assertTrue(R.isSuccess(userListResult), "通过岗位ID查询用户列表失败");
        return userListResult.getData();
    }

    /**
     * 根据用户 ID 列表查询用户名称映射关系
     *
     * @param userIds 用户 ID 列表
     * @return Map，其中 key 为用户 ID，value 为对应的用户名称
     */
    public Map<Long, String> selectUserNamesByIds(List<Long> userIds) {
        R<Map<Long, String>> userNameListResult = systemUserClient.selectUserNamesByIds(userIds);
        AssertUtils.assertTrue(R.isSuccess(userNameListResult), "根据用户ID集合查询用户名称映射关系失败");
        return userNameListResult.getData();
    }

    /**
     * 获取当前登录用户信息
     *
     * @return 用户信息
     */
    public LoginUser getUserInfo() {
        R<LoginUser> userInfoResult = systemUserClient.getUserInfo();
        AssertUtils.assertTrue(R.isSuccess(userInfoResult), "获取当前登录用户信息失败");
        return userInfoResult.getData();
    }

}
